//
//  ExtendView.swift
//  swiftStudy
//
//  Created by ext.zhangjunfei on 2021/7/28.
//

import SwiftUI

struct ExtendView: View {
    
    let code_1:String
    let code_2:String
    let code_3:String
    let code_4:String
    
    init() {
        code_1 =
            """
            //自定义一个类及其子类
            class Car{
                var name:String = "汽车"
            }

            class Audi:Car{
                var brand:String = "奥迪"
            }

            class BMW:Car{
                var brand:String = "宝马"
            }

            //创建实例
            var car = Car()
            var audi = Audi()
            var bmw = BMW()

            //存放在集合中
            var array:[Car] = [car,audi,bmw]

            //遍历集合
            array.forEach { (car) in
                if car is Audi {
                    print("这是辆\\((car as! Audi).brand)")
                }else if car is BMW {
                    print("这是辆\\((car as! BMW).brand)")
                }else {
                    print("这是辆\\(car.name)")
                }
            }
            """
        code_2 =
            """
            //定义泛型,交换两个参数的值
            func exchange<T>(param1 : inout T , param2: inout T){
                let tmp = param1
                param1 = param2
                param2 = tmp
            }

            var p1 = "hello"
            var p2 = "world"
            exchange(param1: &p1, param2: &p2)

            print("\\(p1),\\(p2)")
            """
        code_3 =
            """
            //创建一个类
            class MyClass{
                var name:String
                var age:Int
                
                init(name:String,age:Int) {
                    self.name = name
                    self.age = age
                }
            }

            //为MyClass扩展一个计算属性
            extension MyClass{
                var nameAndAge:String{
                    return "我叫\\(name),今年\\(age)岁了"
                }
            }

            var my = MyClass(name: "Zhang", age: 18)
            print(my.nameAndAge)
            """
        code_4 =
            """
            protocol Test{
                //可读的
                var name:String{get}
                //可读可写的
                var age:Int{get set}
            }

            //创建一个类来遵守Test协议
            class ClassNew:Test{
                
                var name: String
                
                var age: Int
                
                init(){
                    name = "Zhang"
                    age = 18
                }
            }

            var obj = ClassNew()
            """
    }
    
    
    var body: some View {
        ScrollView{
            LazyVStack(alignment: HorizontalAlignment.leading, spacing: 10) {
                Section(header: SectionHeaderView(title: "类型转换")) {
                    CommonTextView(content: "在Swift语言中需要使用相应的关键字来对实例的类型进行检查和转换，系统会帮助开发者监控此次类型转换是否成功。")
                    CommonTextView(content: "在Swift语言中，数据类型的检查和转换需要使用is和as关键字，在使用类型转换时，需要使用as?或as!方式。as?是一种比较安全的方式，转换成功返回实例，转换失败返回nil。as!是一种强制抓换方式，默认一定会转换成功，失败则产生错误。")
                    
                    CodeView(code: code_1).padding(10)
                }
                
                Section(header: SectionHeaderView(title: "泛型")) {
                    CommonTextView(content: "泛型是Swift语言强大的核心之一。泛型是对普通类型的一种抽象。如下：")
                    CodeView(code: code_2).padding(10)
                }
                
                Section(header: SectionHeaderView(title: "扩展")) {
                    CommonTextView(content: "Swift语言中的扩展语法使得数据类型的构建更加灵活，开发者可以为已经存在的数据类型添加新的属性和方法。如下：")
                    CodeView(code: code_3).padding(10)
                }
                
                Section(header: SectionHeaderView(title: "协议")) {
                    CommonTextView(content: "协议是只有属性与方法的声明而没有实现的约定集合，数据类型可以通过实现协议中约定的属性和方法来遵守这个协议。")
                    CommonTextView(content: "协议中可以定义一些属性与方法，这些属性和方法只是声明，协议中并不实现这些属性和方法。协议也不是一种数据类型，没有构造方法也不需要实例化。如下：")
                    CodeView(code: code_4).padding(10)
                
                    CommonTextView(content: "注意：协议中约定的属性是可读时，并非只读的意思，在实现中既可以是只读的也可以是可读可写的。如果协议中约定是可读可写的，则实现必须是可读可写的")
                }
            }
        }
    }
}

struct ExtendView_Previews: PreviewProvider {
    static var previews: some View {
        ExtendView()
    }
}
